home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 001 / pibt40s2.arc / PIBANSIB.MOD < prev    next >
Text File  |  1987-09-22  |  54KB  |  1,529 lines

  1. (*----------------------------------------------------------------------*)
  2. (*        Ansi_Insert_Lines --- Insert empty lines in display           *)
  3. (*----------------------------------------------------------------------*)
  4.  
  5. PROCEDURE Ansi_Insert_Lines;
  6.  
  7. (*----------------------------------------------------------------------*)
  8. (*                                                                      *)
  9. (*     Procedure: Ansi_Insert_Lines;                                    *)
  10. (*                                                                      *)
  11. (*     Purpose:   Inserts empty lines in display                        *)
  12. (*                                                                      *)
  13. (*     Calling Sequence:                                                *)
  14. (*                                                                      *)
  15. (*        Ansi_Insert_Lines;                                            *)
  16. (*                                                                      *)
  17. (*     Called by:  VT100_Process_Escape                                 *)
  18. (*                                                                      *)
  19. (*----------------------------------------------------------------------*)
  20.  
  21. VAR
  22.    L: INTEGER;
  23.    Y: INTEGER;
  24.  
  25. BEGIN (* Ansi_Insert_Lines *)
  26.  
  27.    Y := WhereY;
  28.  
  29.    IF ( ( Y >= Top_Scroll ) AND ( Y <= Bottom_Scroll ) ) THEN
  30.       BEGIN
  31.  
  32.          IF ( Escape_Number = 0 ) THEN
  33.             L := 1
  34.          ELSE
  35.             L := MAX( 1 , Escape_Register[1] );
  36.  
  37.          IF ( ( Y + L - 1 ) > Bottom_Scroll ) THEN
  38.             L := ( Bottom_Scroll - Y + 1 );
  39.  
  40.          IF ( L > 0 ) THEN
  41.             BEGIN
  42.                Scroll( Y, Bottom_Scroll, 1, Max_Screen_Col, -L, FG, BG );
  43.                Ansi_Scroll_Attributes( 1 , Y - 1 );
  44.             END;
  45.  
  46.       END;
  47.  
  48. END   (* Ansi_Insert_Lines *);
  49.  
  50. (*----------------------------------------------------------------------*)
  51. (*        Ansi_Delete_Lines --- Delete empty lines in display           *)
  52. (*----------------------------------------------------------------------*)
  53.  
  54. PROCEDURE Ansi_Delete_Lines;
  55.  
  56. (*----------------------------------------------------------------------*)
  57. (*                                                                      *)
  58. (*     Procedure: Ansi_Delete_Lines;                                    *)
  59. (*                                                                      *)
  60. (*     Purpose:   Deletes lines in display                              *)
  61. (*                                                                      *)
  62. (*     Calling Sequence:                                                *)
  63. (*                                                                      *)
  64. (*        Ansi_Delete_Lines;                                            *)
  65. (*                                                                      *)
  66. (*     Called by:  VT100_Process_Escape                                 *)
  67. (*                                                                      *)
  68. (*----------------------------------------------------------------------*)
  69.  
  70. VAR
  71.    L: INTEGER;
  72.    Y: INTEGER;
  73.  
  74. BEGIN (* Ansi_Delete_Lines *)
  75. {==
  76.    Window( 1, 1, Max_Screen_Col, Ansi_Last_Line );
  77. ==}
  78.    Y := WhereY;
  79.  
  80.    IF ( ( Y >= Top_Scroll ) AND ( Y <= Bottom_Scroll ) ) THEN
  81.       BEGIN
  82.  
  83.          IF ( Escape_Number = 0 ) THEN
  84.             L := 1
  85.          ELSE
  86.             L := MAX( Escape_Register[1] , 1 );
  87.  
  88.          IF ( ( Y + L - 1 ) > Bottom_Scroll ) THEN
  89.             L := ( Bottom_Scroll - Y + 1 );
  90.  
  91.          IF ( L > 0 ) THEN
  92.             BEGIN
  93.                Scroll( Y, Bottom_Scroll, 1, Max_Screen_Col, L, FG, BG );
  94.                Ansi_Scroll_Attributes( -1 , Y - 1 );
  95.             END;
  96.  
  97.       END;
  98. {==
  99.    IF Origin_Mode THEN
  100.       Window( 1, Top_Scroll, Max_Screen_Col, Bottom_Scroll );
  101. ==}
  102. END   (* Ansi_Delete_Lines *);
  103.  
  104. (*----------------------------------------------------------------------*)
  105. (*        Ansi_Delete_Chars --- Delete characters in display            *)
  106. (*----------------------------------------------------------------------*)
  107.  
  108. PROCEDURE Ansi_Delete_Chars;
  109.  
  110. (*----------------------------------------------------------------------*)
  111. (*                                                                      *)
  112. (*     Procedure: Ansi_Delete_Chars;                                    *)
  113. (*                                                                      *)
  114. (*     Purpose:   Deletes characters in display                         *)
  115. (*                                                                      *)
  116. (*     Calling Sequence:                                                *)
  117. (*                                                                      *)
  118. (*        Ansi_Delete_Chars;                                            *)
  119. (*                                                                      *)
  120. (*     Called by:  VT100_Process_Escape                                 *)
  121. (*                                                                      *)
  122. (*----------------------------------------------------------------------*)
  123.  
  124. VAR
  125.    L  : INTEGER;
  126.    I  : INTEGER;
  127.    C1 : INTEGER;
  128.    C2 : INTEGER;
  129.    Y  : INTEGER;
  130.    Ch : CHAR;
  131.    Co : BYTE;
  132.  
  133. BEGIN (* Ansi_Delete_Chars *)
  134.  
  135.    IF ( Escape_Number = 0 ) THEN
  136.       L := 1
  137.    ELSE
  138.       L := MAX( Escape_Register[1] , 1 );
  139.  
  140.    C1 := WhereX;
  141.    C2 := MIN( C1 + L , Wrap_Screen_Col );
  142.    Y  := WhereY + Upper_Left_Row - 1;
  143.  
  144.                                    (* Move characters to left *)
  145.  
  146.    FOR I := C2 TO Wrap_Screen_Col DO
  147.       BEGIN
  148.          ReadCXY ( Ch, I, Y, Co );
  149.          WriteCXY( Ch, C1, Y, Co );
  150.          C1 := SUCC( C1 );
  151.       END;
  152.                                    (* Blank out rest of line *)
  153.  
  154.    IF ( C1 <= Wrap_Screen_Col ) THEN
  155.        BEGIN
  156.  
  157.           GoToXY( C1 , WhereY );
  158.  
  159.           Escape_Number := 0;
  160.           Ansi_Clear_Line;
  161.  
  162.        END;
  163.  
  164. END   (* Ansi_Delete_Chars *);
  165.  
  166. (*----------------------------------------------------------------------*)
  167. (*        Ansi_Insert_Chars --- Insert empty lines in display           *)
  168. (*----------------------------------------------------------------------*)
  169.  
  170. PROCEDURE Ansi_Insert_Chars;
  171.  
  172. (*----------------------------------------------------------------------*)
  173. (*                                                                      *)
  174. (*     Procedure: Ansi_Insert_Chars;                                    *)
  175. (*                                                                      *)
  176. (*     Purpose:   Inserts characters in display                         *)
  177. (*                                                                      *)
  178. (*     Calling Sequence:                                                *)
  179. (*                                                                      *)
  180. (*        Ansi_Insert_Chars;                                            *)
  181. (*                                                                      *)
  182. (*     Called by:  VT100_Process_Escape                                 *)
  183. (*                                                                      *)
  184. (*----------------------------------------------------------------------*)
  185.  
  186. VAR
  187.    I                   : INTEGER;
  188.    L                   : INTEGER;
  189.    Save_Insertion_Mode : BOOLEAN;
  190.    XPos                : INTEGER;
  191.  
  192. BEGIN (* Ansi_Insert_Chars *)
  193.  
  194.    IF ( Escape_Number = 0 ) THEN
  195.       L := 1
  196.    ELSE
  197.       L := Escape_Register[1];
  198.  
  199.    Save_Insertion_Mode := Insertion_Mode;
  200.    Insertion_Mode      := TRUE;
  201.    XPos                := WhereX;
  202.  
  203.    FOR I := 1 TO L DO
  204.       Display_Character( ' ' );
  205.  
  206.    Insertion_Mode      := Save_Insertion_Mode;
  207.  
  208.    GoToXY( XPos , WhereY );
  209.  
  210. END   (* Ansi_Insert_Chars *);
  211.  
  212. (*----------------------------------------------------------------------*)
  213. (*     VT100_Send_Terminal_Parameters --- Send VT100 terminal params    *)
  214. (*----------------------------------------------------------------------*)
  215.  
  216. PROCEDURE VT100_Send_Terminal_Parameters;
  217.  
  218. (*----------------------------------------------------------------------*)
  219. (*                                                                      *)
  220. (*     Procedure: VT100_Send_Terminal_Parameters                        *)
  221. (*                                                                      *)
  222. (*     Purpose:   Sends VT100 terminal parameters                       *)
  223. (*                                                                      *)
  224. (*     Calling Sequence:                                                *)
  225. (*                                                                      *)
  226. (*        VT100_Send_Terminal_Parameters;                               *)
  227. (*                                                                      *)
  228. (*     Called by:  VT100_Process_Escape                                 *)
  229. (*                                                                      *)
  230. (*----------------------------------------------------------------------*)
  231.  
  232. VAR
  233.    PString : AnyStr;
  234.    BString : STRING[5];
  235.  
  236. BEGIN (* VT100_Send_Terminal_Parameters *)
  237.  
  238.    PString := CHR( ESC ) + '[';
  239.  
  240.    IF ( Escape_Register[1] = 1 ) THEN
  241.       PString := PString + '3;'
  242.    ELSE
  243.       PString := PString + '2;';
  244.  
  245.    CASE Parity OF
  246.       'E' : PString := PString + '5;';
  247.       'O' : PString := PString + '4;';
  248.       ELSE  PString := PString + '1;';
  249.    END (* CASE *);
  250.  
  251.    CASE Data_Bits OF
  252.       7    : PString := PString + '2;';
  253.       ELSE   PString := PString + '1;';
  254.    END (* CASE *);
  255.  
  256.    CASE Baud_Rate OF
  257.       300  : BString := '48';
  258.       600  : BString := '56';
  259.       1200 : BString := '64';
  260.       2400 : BString := '88';
  261.       4800 : BString := '104';
  262.       9600 : BString := '112';
  263.       19200: BString := '120';
  264.       ELSE   BString := '0';
  265.    END (* CASE *);
  266.  
  267.    PString := PString + BString + ';' + BString + ';' + '1;0x';
  268.  
  269.    Async_Send_String( PString );
  270.  
  271. END   (* VT100_Send_Terminal_Parameters *);
  272.  
  273. (*----------------------------------------------------------------------*)
  274. (*     VT100_Set_LEDs --- Set LED flags for VT100                       *)
  275. (*----------------------------------------------------------------------*)
  276.  
  277. PROCEDURE VT100_Set_LEDs;
  278.  
  279. (*----------------------------------------------------------------------*)
  280. (*                                                                      *)
  281. (*     Procedure: VT100_Set_LEDs;                                       *)
  282. (*                                                                      *)
  283. (*     Purpose:   Sets VT100 LED flags                                  *)
  284. (*                                                                      *)
  285. (*     Calling Sequence:                                                *)
  286. (*                                                                      *)
  287. (*        VT100_Set_LEDs;                                               *)
  288. (*                                                                      *)
  289. (*     Called by:  VT100_Process_Escape                                 *)
  290. (*                                                                      *)
  291. (*----------------------------------------------------------------------*)
  292.  
  293. VAR
  294.    Led_Number : INTEGER;
  295.    I          : INTEGER;
  296.  
  297. BEGIN (* VT100_Set_LEDs *)
  298.  
  299.    IF ( Escape_Number = 0 ) THEN
  300.       BEGIN
  301.          Escape_Number      := 1;
  302.          Escape_Register[1] := 0;
  303.       END;
  304.  
  305.    FOR I := 1 TO Escape_Number DO
  306.       CASE Escape_Register[I] OF
  307.  
  308.          0: BEGIN (* Turn off all LEDs *)
  309.                VT100_Led_Vector[1] := FALSE;
  310.                VT100_Led_Vector[2] := FALSE;
  311.                VT100_Led_Vector[3] := FALSE;
  312.                VT100_Led_Vector[4] := FALSE;
  313.             END;
  314.  
  315.          1: VT100_Led_Vector[1] := TRUE;
  316.          2: VT100_Led_Vector[2] := TRUE;
  317.          3: VT100_Led_Vector[3] := TRUE;
  318.          4: VT100_Led_Vector[4] := TRUE;
  319.  
  320.          ELSE;
  321.  
  322.       END (* CASE *);
  323.  
  324. END   (* VT100_Set_LEDs *);
  325.  
  326. (*----------------------------------------------------------------------*)
  327. (*            Ansi_Reset_Terminal --- Reset terminal defaults           *)
  328. (*----------------------------------------------------------------------*)
  329.  
  330. PROCEDURE Ansi_Reset_Terminal;
  331.  
  332. (*----------------------------------------------------------------------*)
  333. (*                                                                      *)
  334. (*     Procedure: Ansi_Reset_Terminal                                   *)
  335. (*                                                                      *)
  336. (*     Purpose:   Resets terminal defaults                              *)
  337. (*                                                                      *)
  338. (*     Calling Sequence:                                                *)
  339. (*                                                                      *)
  340. (*        Ansi_Reset_Terminal;                                          *)
  341. (*                                                                      *)
  342. (*     Called by:  Emulate_Ansi                                         *)
  343. (*                                                                      *)
  344. (*----------------------------------------------------------------------*)
  345.  
  346. BEGIN (* Ansi_Reset_Terminal *)
  347.                                    (* Initialize error handler. *)
  348.    ErrorPtr := OFS( Trap_Error );
  349.                                    (* Turn on the cursor            *)
  350.    CursorOn;
  351.                                    (* Initialize terminal state     *)
  352.    Done                  := FALSE;
  353.    Alt_Keypad_Mode       := OFF;
  354.    Graphics_Mode         := OFF;
  355.    Auto_Print_Mode       := OFF;
  356.    Origin_Mode           := OFF;
  357.    Auto_Wrap_Mode        := ON;
  358.    Printer_Ctrl_Mode     := OFF;
  359.    Escape_Mode           := FALSE;
  360.    Escape_Str[0]         := #0;
  361.    NewX                  := WhereX;
  362.    NewY                  := WhereY;
  363.    Skip_All_Mode         := FALSE;
  364.    Double_Width_Mode     := FALSE;
  365.    New_Line              := FALSE;
  366.    Save_Done             := FALSE;
  367.    Insertion_Mode        := FALSE;
  368.    VT100_G0_Set          := 'A';
  369.    VT100_G1_Set          := 'A';
  370.    VT100_G0_State        := TRUE;
  371.    Wrap_Screen_Col       := 80;
  372.    Current_Status_Time   := -1;
  373.  
  374.                                    (* Set tabs *)
  375.    Number_VT100_Tabs     := 17;
  376.  
  377.    FOR ITab := 1 TO 9 DO
  378.       VT100_Tabs[ITab] := ITab * 8 + 1;
  379.  
  380.    FOR ITab := 10 TO 16 DO
  381.       VT100_Tabs[ITab] := 64 + ITab;
  382.  
  383.    VT100_Tabs[17] := Wrap_Screen_Col;
  384.  
  385.                                    (* Set colors.                *)
  386.  
  387.    Ansi_ForeGround_Color := VT100_ForeGround_Color;
  388.    Ansi_BackGround_Color := VT100_BackGround_Color;
  389.    Ansi_Underline_Color  := VT100_Underline_Color;
  390.    Ansi_Bold_Color       := VT100_Bold_Color;
  391.  
  392.    ForeGround_Color      := VT100_ForeGround_Color;
  393.    BackGround_Color      := VT100_BackGround_Color;
  394.    Border_Color          := VT100_Border_Color;
  395.  
  396.    FG                    := VT100_ForeGround_Color;
  397.    BG                    := VT100_BackGround_Color;
  398.  
  399.    Bolding_On            := FALSE;
  400.    Blinking_On           := FALSE;
  401.    Reverse_On            := FALSE;
  402.  
  403.    Set_Global_Colors( Ansi_ForeGround_Color , Ansi_BackGround_Color );
  404.    Set_Border_Color ( Border_Color );
  405.  
  406.                                    (* Initialize music playing   *)
  407.    PibPlaySet;
  408.    Getting_Music := FALSE;
  409.                                    (* Set status line attribute *)
  410.  
  411.    IF Reverse_Status_Colors THEN
  412.       Status_Line_Attr := 16 * ( ForeGround_Color AND 7 ) + BackGround_Color
  413.    ELSE
  414.       Status_Line_Attr := 16 * ( Status_BackGround_Color AND 7 ) + Status_ForeGround_Color;
  415.  
  416.    Do_Status_Line   := Show_Status_Line;
  417.    Do_Status_Time   := Do_Status_Line AND Show_Status_Time;
  418.  
  419.    IF VT100_Allowed THEN
  420.       BEGIN
  421.          Ansi_Last_Line      := Max_Screen_Line - 1;
  422.          Short_Terminal_Name := 'VT100';
  423.       END
  424.    ELSE
  425.       BEGIN
  426.          Ansi_Last_Line      := Max_Screen_Line;
  427.          Short_Terminal_Name := 'ANSI/BBS';
  428.       END;
  429.  
  430.    Set_Status_Line_Name(Short_Terminal_Name);
  431.  
  432.                                    (* Status line to last line *)
  433.    IF Do_Status_Line THEN
  434.       BEGIN
  435.          Ansi_Last_Line := Max_Screen_Line - 1;
  436.          Write_To_Status_Line( Status_Line_Name, 1 );
  437.       END;
  438.                                    (* Set screen size            *)
  439.  
  440.    Window( 1, 1, Max_Screen_Col, Ansi_Last_Line );
  441.  
  442.                                    (* Ensure proper screen length *)
  443.  
  444.    Set_Screen_Size( Ansi_Last_Line , Max_Screen_Col );
  445.  
  446.                                    (* Change text attributes     *)
  447.  
  448.    Set_Text_Attributes( 1, 1, Max_Screen_Col, Ansi_Last_Line,
  449.                         Ansi_ForeGround_Color,
  450.                         Ansi_BackGround_Color );
  451.  
  452.                                    (* Initial scrolling region is *)
  453.                                    (* entire usable screen.       *)
  454.  
  455.    Top_Scroll            := 1;
  456.    Bottom_Scroll         := Ansi_Last_Line;
  457.  
  458.                                    (* Set line attributes all normal  *)
  459.  
  460.    FillChar( Line_Attributes, Max_Screen_Line, 0 );
  461.  
  462.                                    (* Special keyboard and output chars *)
  463.    FOR ITab := 0 TO 255 DO
  464.       Special_Comm [ITab] := FALSE;
  465.  
  466.    Special_Comm[NUL]  := TRUE;
  467.    Special_Comm[ESC]  := TRUE;
  468.    Special_Comm[LF ]  := TRUE;
  469.    Special_Comm[CR ]  := TRUE;
  470.    Special_Comm[FF ]  := TRUE;
  471.    Special_Comm[VT ]  := TRUE;
  472.    Special_Comm[HT ]  := TRUE;
  473.    Special_Comm[ENQ]  := TRUE;
  474.    Special_Comm[SO ]  := TRUE;
  475.    Special_Comm[SI ]  := TRUE;
  476.    Special_Comm[DEL]  := TRUE;
  477.    Special_Comm[BS ]  := TRUE;
  478.    Special_Comm[CAN]  := TRUE;
  479.    Special_Comm[SUB]  := TRUE;
  480.  
  481.                                    (* Set time for status line   *)
  482.    Current_Status_Time := -1;
  483.                                    (* Check if script tests req'd *)
  484.  
  485.    Do_Script_Tests := Waitstring_Mode OR When_Mode OR
  486.                       WaitCount_Mode  OR WaitQuiet_Mode OR
  487.                       Script_Learn_Mode;
  488.  
  489.                                    (* Set save guys *)
  490.  
  491.    Save_Col_Position  := NewX - 1;
  492.    Save_Row_Position  := NewY - 1;
  493.    Save_FG_Color      := FG;
  494.    Save_BG_Color      := BG;
  495.    Save_Graphics_Mode := Graphics_Mode;
  496.    Save_Bolding       := Bolding_On;
  497.    Save_Blinking      := Blinking_On;
  498.    Save_Origin_Mode   := Origin_Mode;
  499.    Save_Top_Scroll    := Top_Scroll;
  500.    Save_Bottom_Scroll := Bottom_Scroll;
  501.  
  502.                                    (* No LEDs lit *)
  503.    VT100_Led_Vector[1] := FALSE;
  504.    VT100_Led_Vector[2] := FALSE;
  505.    VT100_Led_Vector[3] := FALSE;
  506.    VT100_Led_Vector[4] := FALSE;
  507.  
  508. END   (* Ansi_Reset_Terminal *);
  509.  
  510. (*----------------------------------------------------------------------*)
  511. (*            Ansi_Process_Escape --- Process ANSI escape sequence      *)
  512. (*----------------------------------------------------------------------*)
  513.  
  514. PROCEDURE Ansi_Process_Escape( Ch : CHAR );
  515.  
  516. (*----------------------------------------------------------------------*)
  517. (*                                                                      *)
  518. (*     Procedure: Ansi_Process_Escape                                   *)
  519. (*                                                                      *)
  520. (*     Purpose:   Processes escape sequence for BBS/ANSI emulation      *)
  521. (*                                                                      *)
  522. (*     Calling Sequence:                                                *)
  523. (*                                                                      *)
  524. (*        Ansi_Process_Escape( Ch: CHAR );                              *)
  525. (*                                                                      *)
  526. (*           Ch --- Next character in escape sequence                   *)
  527. (*                                                                      *)
  528. (*     Called by:  Emulate_Ansi                                         *)
  529. (*                                                                      *)
  530. (*     Remarks:                                                         *)
  531. (*                                                                      *)
  532. (*        This version doesn't process private DEC escape sequences,    *)
  533. (*        but DOES play music.                                          *)
  534. (*                                                                      *)
  535. (*----------------------------------------------------------------------*)
  536.  
  537. VAR
  538.    Reg_Val     : INTEGER;
  539.    Save_X      : INTEGER;
  540.    Save_Y      : INTEGER;
  541.    More_Escape : BOOLEAN;
  542.  
  543. BEGIN (* Ansi_Process_Escape *)
  544.  
  545.    IF Getting_Music THEN
  546.       BEGIN
  547.          IF ( ORD( Escape_Str[0] ) < 255 ) THEN
  548.             Escape_Str := Escape_Str + Ch;
  549.          EXIT;
  550.       END;
  551.  
  552.    More_Escape := FALSE;
  553.  
  554.    CASE Ch OF
  555.  
  556.       ' ' : EXIT;
  557.       ^M  : EXIT;
  558.       ^J  : EXIT;
  559.  
  560.       '[' : BEGIN
  561.                Escape_Type    := '[';
  562.                EXIT;
  563.             END;
  564.  
  565.       'A' : IF Escape_Type <> '[' THEN
  566.                More_Escape := TRUE
  567.             ELSE
  568.                Ansi_Cursor_Up;
  569.  
  570.       'B' : IF Escape_Type <> '[' THEN
  571.                More_Escape := TRUE
  572.             ELSE
  573.                Ansi_Cursor_Down;
  574.  
  575.       'C' : IF Escape_Type <> '[' THEN
  576.                More_Escape := TRUE
  577.             ELSE
  578.                Ansi_Cursor_Right;
  579.  
  580.       'D' : IF Escape_Type <> '[' THEN
  581.                More_Escape := TRUE
  582.             ELSE
  583.                Ansi_Cursor_Left;
  584.  
  585.       'f' : Ansi_Set_Cursor;
  586.  
  587.       'H' : Ansi_Set_Cursor;
  588.  
  589.       'J' : Ansi_Clear_Screen;
  590.  
  591.       'K' : Ansi_Clear_Line;
  592.  
  593.       'L' : BEGIN
  594.                Scroll( WhereY, Bottom_Scroll, 1, Max_Screen_Col, -1, FG, BG );
  595.                ClrEol;
  596.             END;
  597.  
  598.       'M' : BEGIN
  599.                Getting_Music := TRUE;
  600.                More_Escape   := TRUE;
  601.             END;
  602.  
  603.       'm' : Ansi_Set_Graphics;
  604.                                    (* Indicate EXEC PC AutoDownload possible *)
  605.  
  606.       ^Q  : IF Mahoney_On THEN Async_Send_String( 'EXECPC2' );
  607.  
  608.       'O':  IF Mahoney_On THEN Exec_PC_Commands;
  609.  
  610.       's':  IF Escape_Type = '[' THEN
  611.                BEGIN
  612.                   Save_Row_Position  := WhereX;
  613.                   Save_Col_Position  := WhereY;
  614.                   Save_FG_Color      := FG;
  615.                   Save_BG_Color      := BG;
  616.                   Save_Graphics_Mode := Graphics_Mode;
  617.                   Save_Bolding       := Bolding_On;
  618.                   Save_Blinking      := Blinking_On;
  619.                END
  620.             ELSE
  621.                More_Escape := TRUE;
  622.  
  623.       'u':  IF Escape_Type = '[' THEN
  624.                BEGIN
  625.                   MoveToXY( Save_Row_Position , Save_Col_Position );
  626.                   FG            := Save_FG_Color;
  627.                   BG            := Save_BG_Color;
  628.                   Bolding_On    := Save_Bolding;
  629.                   Blinking_On   := Save_Blinking;
  630.                   Graphics_Mode := Save_Graphics_Mode;
  631.                   IF Blinking_On THEN
  632.                      TextColor( FG + Blink )
  633.                   ELSE
  634.                      TextColor( FG );
  635.                   TextBackGround( BG );
  636.                END
  637.             ELSE
  638.                More_Escape := TRUE;
  639.  
  640.       ELSE  More_Escape := TRUE;
  641.  
  642.    END  (* CASE *);
  643.  
  644.    IF ( NOT More_Escape ) THEN
  645.       Escape_Mode := FALSE
  646.    ELSE
  647.       BEGIN
  648.  
  649.          Ch         := UpCase( Ch );
  650.          Escape_Str := Escape_Str + Ch;
  651.  
  652.          IF Ch IN Lets THEN EXIT;
  653.  
  654.          IF Ch IN Digits THEN
  655.             BEGIN
  656.                Escape_Register[Escape_Number] :=
  657.                   ( Escape_Register[Escape_Number] * 10 ) + ORD( Ch ) -
  658.                                                             ORD( '0' );
  659.                EXIT;
  660.             END;
  661.  
  662.          CASE Ch OF
  663.  
  664.             ';', ',' : BEGIN
  665.                           Escape_Number                  := Escape_Number + 1;
  666.                           Escape_Register[Escape_Number] := 0;
  667.                        END;
  668.  
  669.             'T', 'S', '#', '+', '-', '>', '<', '.'
  670.                         : ;
  671.             ELSE
  672.                Escape_Mode := FALSE;
  673.                Ansi_Write_Escape;
  674.  
  675.          END  (* CASE *);
  676.  
  677.    END (* NOT More_Escape *);
  678.  
  679. END   (* Ansi_Process_Escape *);
  680.  
  681.  
  682. (*----------------------------------------------------------------------*)
  683. (*        Handle_VT100_Special --- Process special chars in VT100       *)
  684. (*----------------------------------------------------------------------*)
  685.  
  686. PROCEDURE Handle_VT100_Special( Comm_Ch: CHAR );
  687.  
  688. VAR
  689.    Save_Y: INTEGER;
  690.  
  691. BEGIN (* Handle_VT100_Special *)
  692.  
  693.    Do_Graphics_Mode := Graphics_Mode;
  694.    Graphics_Mode    := OFF;
  695.  
  696.    CASE ORD( Comm_Ch ) OF
  697.  
  698.       ESC:  BEGIN (* ESC found *)
  699.  
  700.                IF Escape_Mode THEN Ansi_Write_Escape;
  701.  
  702.                Escape_Str[0]      := #0;
  703.                Escape_Number      := 1;
  704.                Escape_Register[1] := 0;
  705.                Escape_Mode        := TRUE;
  706.                Escape_Type        := ' ';
  707.                Getting_Music      := FALSE;
  708.  
  709.             END;
  710.  
  711.       LF,
  712.       FF,
  713.       VT:   BEGIN (* go down one line *)
  714.  
  715.                Save_Y   := WhereY;
  716.  
  717.                IF Auto_Print_Mode THEN
  718.                   BEGIN
  719.                      Get_Screen_Text_Line( Print_Line, Save_Y, 1 );
  720.                      WRITELN( Lst , Print_Line );
  721.                   END;
  722.  
  723.                IF VT100_Allowed THEN
  724.                   BEGIN
  725.                      Save_FG1 := FG;
  726.                      Save_BG1 := BG;
  727.                      TextColor     ( Ansi_ForeGround_Color );
  728.                      TextBackGround( Ansi_BackGround_Color );
  729.                   END;
  730.  
  731.                IF ( Save_Y <= Bottom_Scroll  ) THEN
  732.                   BEGIN
  733.  
  734.                      IF ( Save_Y = Bottom_Scroll ) THEN
  735.                          BEGIN
  736.  
  737.                             Window( 1, Top_Scroll, Max_Screen_Col,
  738.                                     Bottom_Scroll );
  739.  
  740.                             Display_Character( Comm_Ch );
  741. {==
  742.                             IF ( NOT Origin_Mode ) THEN
  743. ==}
  744.                                Window( 1, 1, Max_Screen_Col, Ansi_Last_Line );
  745.  
  746.                             MOVE( Line_Attributes[ Top_Scroll + 1 ],
  747.                                   Line_Attributes[ Top_Scroll     ],
  748.                                   Bottom_Scroll - Top_Scroll );
  749.  
  750.                             Line_Attributes[ Bottom_Scroll ] := 0;
  751.                             ClrEol;
  752.  
  753.                          END
  754.                       ELSE
  755.                          Display_Character( Comm_Ch );
  756.  
  757.                       IF Do_Script_Tests THEN
  758.                          Do_Script_Checks( Comm_Ch );
  759.  
  760.                   END
  761.                ELSE
  762.                   BEGIN
  763.  
  764.                      IF ( Save_Y < Ansi_Last_Line ) THEN
  765.                         Display_Character( Comm_Ch );
  766.  
  767.                      IF Capture_On THEN
  768.                         Capture_Char( Comm_Ch );
  769.  
  770.                      IF Printer_On THEN
  771.                          WRITE( Lst , Comm_Ch );
  772.  
  773.                      IF Review_On THEN
  774.                          Update_Review_Pointers;
  775.  
  776.                      IF Do_Script_Tests THEN
  777.                         Do_Script_Checks( Comm_Ch );
  778.  
  779.                   END;
  780.  
  781.                IF VT100_Allowed THEN
  782.                   BEGIN
  783.                      TextColor     ( Save_FG1 );
  784.                      TextBackGround( Save_BG1 );
  785.                   END;
  786.  
  787.             END   (* go down one line *);
  788.  
  789.                                    (* Move to specified tab column *)
  790.  
  791.       HT:   IF VT100_Allowed THEN
  792.                Handle_Tab( VT100_Tabs , Number_VT100_Tabs )
  793.             ELSE
  794.                BEGIN
  795.                   Display_Character( Comm_Ch );
  796.                   IF Do_Script_Tests THEN
  797.                      Do_Script_Checks( Comm_Ch );
  798.                END;
  799.  
  800.       SO:   IF VT100_Allowed THEN
  801.                BEGIN
  802.                   VT100_G0_State   := FALSE;
  803.                   Do_Graphics_Mode := ( VT100_G1_Set = '0' );
  804.                END
  805.             ELSE
  806.                BEGIN
  807.                   IF ( Play_Music_On ) AND ( NOT Silent_Mode ) THEN
  808.                      PibPlay( Escape_Str );
  809.                   Escape_Mode   := FALSE;
  810.                   Escape_Str[0] := #0;
  811.                END;
  812.  
  813.       SI:   IF VT100_Allowed THEN
  814.                BEGIN
  815.                   VT100_G0_State   := TRUE;
  816.                   Do_Graphics_Mode := ( VT100_G0_Set = '0' );
  817.                END
  818.             ELSE
  819.                BEGIN
  820.                   Display_Character( Comm_Ch );
  821.                   IF Do_Script_Tests THEN
  822.                      Do_Script_Checks( Comm_Ch );
  823.                END;
  824.  
  825.                                    (* CompuServe B protocol request *)
  826.  
  827.       ENQ:  IF CompuServe_B_On THEN
  828.                B := Do_CompuServe_B_Transfer
  829.             ELSE
  830.                IF VT100_Allowed THEN
  831.                   Async_Send_String( VT100_Answerback_Message )
  832.                ELSE
  833.                   BEGIN
  834.                      Display_Character( Comm_Ch );
  835.                      IF Do_Script_Tests THEN
  836.                         Do_Script_Checks( Comm_Ch );
  837.                   END;
  838.                                    (* Cancel escape sequence in progress *)
  839.       CAN,
  840.       ENQ:  IF Escape_Mode THEN
  841.                BEGIN
  842.                   Escape_Mode := FALSE
  843.                END
  844.             ELSE
  845.                BEGIN
  846.                   Display_Character( Comm_Ch );
  847.                   IF Do_Script_Tests THEN
  848.                      Do_Script_Checks( Comm_Ch );
  849.                END;
  850.  
  851.       ELSE
  852.             BEGIN
  853.                Display_Character( Comm_Ch );
  854.                IF Do_Script_Tests THEN
  855.                   Do_Script_Checks( Comm_Ch );
  856.             END;
  857.  
  858.    END  (* CASE *);
  859.  
  860.    Graphics_Mode := Do_Graphics_Mode;
  861.  
  862. END   (* Handle_VT100_Special *);
  863.  
  864. (*----------------------------------------------------------------------*)
  865. (*         VT100_Process_Escape --- Process VT100 escape sequence       *)
  866. (*----------------------------------------------------------------------*)
  867.  
  868. PROCEDURE VT100_Process_Escape(     Ch   : CHAR;
  869.                                 VAR Done : BOOLEAN );
  870.  
  871. (*----------------------------------------------------------------------*)
  872. (*                                                                      *)
  873. (*     Procedure: VT100_Process_Escape                                  *)
  874. (*                                                                      *)
  875. (*     Purpose:   Processes escape sequence for DEC VT100 emulation     *)
  876. (*                                                                      *)
  877. (*     Calling Sequence:                                                *)
  878. (*                                                                      *)
  879. (*        VT100_Process_Escape( Ch: CHAR; VAR Done: BOOLEAN );          *)
  880. (*                                                                      *)
  881. (*           Ch --- Next character in escape sequence                   *)
  882. (*           Done --- Set TRUE to exit ANSI/VT100 mode                  *)
  883. (*                                                                      *)
  884. (*     Called by:  Emulate_Ansi                                         *)
  885. (*                                                                      *)
  886. (*     Remarks:                                                         *)
  887. (*                                                                      *)
  888. (*        This version processes private DEC escape sequences.          *)
  889. (*                                                                      *)
  890. (*----------------------------------------------------------------------*)
  891.  
  892. VAR
  893.    Reg_Val     : INTEGER;
  894.    Save_X      : INTEGER;
  895.    Save_Y      : INTEGER;
  896.    I           : INTEGER;
  897.    J           : INTEGER;
  898.    More_Escape : BOOLEAN;
  899.    S           : AnyStr;
  900.    Regs        : RegPack;
  901.  
  902. (* STRUCTURED *) CONST
  903.    VT100_Char_Sets : SET OF CHAR = ['A','B','0','1','2'];
  904.  
  905. BEGIN (* VT100_Process_Escape *)
  906.  
  907.    More_Escape := FALSE;
  908.                                    (* Ignore blanks *)
  909.    IF ( Ch = ' ' ) THEN EXIT;
  910.                                    (* Process char depending upon current *)
  911.                                    (* escape type mode                    *)
  912.    CASE Escape_Type OF
  913.  
  914.       ' ':  CASE Ch OF
  915.  
  916.                '#',
  917.                '[',
  918.                'O',
  919.                '?':   BEGIN
  920.                          Escape_Type := Ch;
  921.                          EXIT;
  922.                       END;
  923.  
  924.                'D':   BEGIN
  925.                          IF ( WhereY < Bottom_Scroll ) THEN
  926.                             BEGIN
  927.                                MoveToXY( WhereX , WhereY + 1 );
  928.                                Last_Column_Hit := FALSE;
  929.                             END
  930.                          ELSE
  931.                             BEGIN
  932.                                Save_X := WhereX;
  933.                                Save_Y := WhereY;
  934.                                Scroll( Top_Scroll, Bottom_Scroll, 1,
  935.                                        Max_Screen_Col, 1, FG, BG );
  936.                                MoveToXY( Save_X, Save_Y );
  937.                                Ansi_Scroll_Attributes( 1 , Bottom_Scroll );
  938.                             END;
  939.                       END;
  940.  
  941.                'E':   BEGIN
  942.                          IF ( WhereY < Bottom_Scroll ) THEN
  943.                             BEGIN
  944.                                MoveToXY( 1 , WhereY + 1 );
  945.                                Last_Column_Hit := FALSE;
  946.                             END
  947.                          ELSE
  948.                             BEGIN
  949.                                Save_Y := WhereY;
  950.                                Scroll( Top_Scroll, Bottom_Scroll, 1,
  951.                                        Max_Screen_Col, 1, FG, BG );
  952.                                MoveToXY( 1 , Save_Y );
  953.                                Ansi_Scroll_Attributes( 1 , Bottom_Scroll );
  954.                             END;
  955.                       END;
  956.  
  957.                'M':   BEGIN
  958. {==
  959.                          Window( 1, 1, Max_Screen_Col, Ansi_Last_Line );
  960. ==}
  961.                          IF WhereY > Top_Scroll THEN
  962.                             BEGIN
  963.                                MoveToXY( WhereX , WhereY - 1 );
  964.                                Last_Column_Hit := FALSE;
  965.                             END
  966.                          ELSE
  967.                             BEGIN
  968.  
  969.                                Save_X  := WhereX;
  970.                                Save_Y  := WhereY;
  971.                                Save_FG := FG;
  972.                                Save_BG := BG;
  973.                                FG      := Ansi_ForeGround_Color;
  974.                                BG      := Ansi_BackGround_Color;
  975.  
  976.                                Scroll( Top_Scroll, Bottom_Scroll, 1, Max_Screen_Col,
  977.                                        -1, FG, BG );
  978.  
  979.                                FG      := Save_FG;
  980.                                BG      := Save_BG;
  981.  
  982.                                Ansi_Scroll_Attributes( -1, Bottom_Scroll - 1 );
  983.  
  984.                                MoveToXY( Save_X, Save_Y );
  985.  
  986.                             END;
  987. {==
  988.                          IF Origin_Mode THEN
  989.                             Window( 1, Top_Scroll, Max_Screen_Col, Bottom_Scroll );
  990. ==}
  991.                       END;
  992.  
  993.                '7':   BEGIN
  994.                          Regs.Ah            := 3;
  995.                          Regs.Bh            := 0;
  996.                          INTR( $10 , Regs );
  997.                          Save_Col_Position  := Regs.Dl;
  998.                          Save_Row_Position  := Regs.Dh;
  999.                          Save_FG_Color      := FG;
  1000.                          Save_BG_Color      := BG;
  1001.                          Save_Graphics_Mode := Graphics_Mode;
  1002.                          Save_Bolding       := Bolding_On;
  1003.                          Save_Blinking      := Blinking_On;
  1004.                          Save_Done          := TRUE;
  1005.                          Save_Top_Scroll    := Top_Scroll;
  1006.                          Save_Bottom_Scroll := Bottom_Scroll;
  1007.                          Save_Origin_Mode   := Origin_Mode;
  1008.                       END;
  1009.  
  1010.                '8':   BEGIN
  1011.                          Regs.Ah       := 2;
  1012.                          Regs.Bh       := 0;
  1013.                          Regs.Dh       := Save_Row_Position;
  1014.                          Regs.Dl       := Save_Col_Position;
  1015.                          INTR( $10 , Regs );
  1016.                          FG            := Save_FG_Color;
  1017.                          BG            := Save_BG_Color;
  1018.                          Bolding_On    := Save_Bolding;
  1019.                          Blinking_On   := Save_Blinking;
  1020.                          Graphics_Mode := Save_Graphics_Mode;
  1021. {
  1022.                          Top_Scroll    := Save_Top_Scroll;
  1023.                          Bottom_Scroll := Save_Bottom_Scroll;
  1024.                          Origin_Mode   := Save_Origin_Mode;
  1025. }
  1026.                          IF Blinking_On THEN
  1027.                            TextColor( FG + Blink )
  1028.                          ELSE
  1029.                            TextColor( FG );
  1030.                          TextBackGround( BG );
  1031.                          Set_Global_Colors( FG , BG );
  1032.                       END;
  1033.  
  1034.                'H':   VT100_Set_Tab;
  1035.  
  1036.                ')':   BEGIN
  1037.                          Escape_Type   := ')';
  1038.                          Ch            := Ansi_Next_Char;
  1039.                          IF ( Ch IN VT100_Char_Sets ) THEN
  1040.                             BEGIN
  1041.                                VT100_G1_Set := Ch;
  1042.                                IF ( NOT VT100_G0_State ) THEN
  1043.                                   Graphics_Mode := ( VT100_G1_Set = '0' );
  1044.                             END;
  1045.                       END;
  1046.  
  1047.                '(':   BEGIN
  1048.                          Escape_Type   := '(';
  1049.                          Ch            := Ansi_Next_Char;
  1050.                          IF ( Ch IN VT100_Char_Sets ) THEN
  1051.                             BEGIN
  1052.                                VT100_G0_Set := Ch;
  1053.                                IF VT100_G0_State THEN
  1054.                                   Graphics_Mode := ( VT100_G0_Set = '0' );
  1055.                             END;
  1056.                       END;
  1057.  
  1058.                '<':   BEGIN
  1059.                          Escape_Mode := FALSE;
  1060.                          EXIT;
  1061.                       END;
  1062.  
  1063.                'r':   BEGIN               (* Terminal Reset      *)
  1064.                          Top_Scroll    := 1;
  1065.                          Bottom_Scroll := Ansi_Last_Line;
  1066.                          Clear_Window;
  1067.                          FillChar( Line_Attributes, Max_Screen_Line, 0 );
  1068.                       END;
  1069.  
  1070.                'Z':   Async_Send_String( CHR( 27 ) + '[?1;0c' );
  1071.  
  1072.                '=':   Alt_Keypad_Mode := ON;
  1073.  
  1074.                '>':   Alt_Keypad_Mode := OFF;
  1075.  
  1076.                'c':   Ansi_Reset_Terminal;
  1077.  
  1078.                ELSE   More_Escape := TRUE;
  1079.  
  1080.             END (* CASE *);
  1081.  
  1082.       '[':  CASE Ch OF
  1083.  
  1084.                '?':   BEGIN
  1085.                          Escape_Type := Ch;
  1086.                          EXIT;
  1087.                       END;
  1088.  
  1089.                'A':   Ansi_Cursor_Up;
  1090.  
  1091.                'B':   Ansi_Cursor_Down;
  1092.  
  1093.                'C':   Ansi_Cursor_Right;
  1094.  
  1095.                'D':   Ansi_Cursor_Left;
  1096.  
  1097.                'H':   Ansi_Set_Cursor;
  1098.  
  1099.                'J':   Ansi_Clear_Screen;
  1100.  
  1101.                'K':   Ansi_Clear_Line;
  1102.  
  1103.                'L':   Ansi_Insert_Lines;
  1104.  
  1105.                'f':   Ansi_Set_Cursor;
  1106.  
  1107.                '}',
  1108.                'm':   Ansi_Set_Graphics;
  1109.  
  1110.                'r':   Ansi_Set_Scrolling_Region;
  1111.  
  1112.                'h':   Ansi_Set_Mode(' ');
  1113.  
  1114.                'i':   Ansi_Printer_Control(' ');
  1115.  
  1116.                'l':   Ansi_Reset_Mode( ' ' , Done );
  1117.  
  1118.                'g':   VT100_Clear_Tabs;
  1119.  
  1120.                'M':   Ansi_Delete_Lines;
  1121.  
  1122.                'c':   Async_Send_String( CHR( 27 ) + '[?1;0c' );
  1123.  
  1124.                'n':   Ansi_Status_Report;
  1125.  
  1126.                'P':   Ansi_Delete_Chars;
  1127.  
  1128.                'q':   VT100_Set_LEDs;
  1129.  
  1130.                's':   (* Protected fields not implemented *);
  1131.  
  1132.                'x':   VT100_Send_Terminal_Parameters;
  1133.  
  1134.                'y':   ;
  1135.  
  1136.                '@':   Ansi_Insert_Chars;
  1137.  
  1138.                ELSE   More_Escape := TRUE;
  1139.  
  1140.             END (* CASE *);
  1141.  
  1142.       '?':  CASE Ch OF
  1143.  
  1144.                'h':   Ansi_Set_Mode('?');
  1145.  
  1146.                'i':   Ansi_Printer_Control('?');
  1147.  
  1148.                'l':   Ansi_Reset_Mode( '?' , Done );
  1149.  
  1150.                ELSE   More_Escape := TRUE;
  1151.  
  1152.             END (* CASE *);
  1153.  
  1154.       '#':  CASE Ch OF
  1155.  
  1156.                '3',
  1157.                '4',
  1158.                '5',
  1159.                '6':  BEGIN
  1160.                         Reg_Val := ORD( Ch ) - ORD('0');
  1161.                         IF ( Reg_Val = 5 ) THEN
  1162.                            Reg_Val := 0;
  1163.                         Line_Attributes[ WhereY ] := Reg_Val;
  1164.                         Set_Cursor( WhereX , WhereY );
  1165.                      END;
  1166.  
  1167.                '8':  BEGIN
  1168.                         S := DUPL( 'E', Wrap_Screen_Col );
  1169.                         FOR I := 1 TO ( Max_Screen_Line - 1 ) DO
  1170.                             WriteSXY( S, 1, I,
  1171.                                       ( Global_BackGround_Color AND 7 ) SHL 4  +
  1172.                                       Global_ForeGround_Color );
  1173.                      END;
  1174.  
  1175.                ELSE   More_Escape := TRUE;
  1176.  
  1177.             END (* CASE *);
  1178.  
  1179.       'O':  CASE Ch OF
  1180.  
  1181.                'A':   Ansi_Cursor_Up;
  1182.  
  1183.                'B':   Ansi_Cursor_Down;
  1184.  
  1185.                'C':   Ansi_Cursor_Right;
  1186.  
  1187.                'D':   Ansi_Cursor_Left;
  1188.  
  1189.                ELSE   More_Escape := TRUE;
  1190.  
  1191.             END (* CASE *);
  1192.  
  1193.       ELSE  More_Escape := TRUE;
  1194.  
  1195.    END (* CASE Escape_Type *);
  1196.  
  1197.    IF ( NOT More_Escape ) THEN
  1198.       Escape_Mode := FALSE
  1199.    ELSE
  1200.       BEGIN
  1201.  
  1202.          Ch         := UpCase( Ch );
  1203.          Escape_Str := Escape_Str + Ch;
  1204.  
  1205.          IF Ch IN Lets THEN EXIT;
  1206.  
  1207.          IF Ch IN Digits THEN
  1208.             BEGIN
  1209.                Escape_Register[Escape_Number] :=
  1210.                   ( Escape_Register[Escape_Number] * 10 ) + ORD( Ch ) -
  1211.                                                             ORD( '0' );
  1212.                EXIT;
  1213.             END;
  1214.  
  1215.          CASE Ch OF
  1216.  
  1217.             ';', ',' : BEGIN
  1218.                           Escape_Number                  := Escape_Number + 1;
  1219.                           Escape_Register[Escape_Number] := 0;
  1220.                        END;
  1221.  
  1222.             'T', 'S', '#', '+', '-', '>', '<', '.','?','='
  1223.                         : ;
  1224.             ELSE
  1225.                Escape_Mode := FALSE;
  1226.                Ansi_Write_Escape;
  1227.  
  1228.          END  (* Case *);
  1229.  
  1230.       END (* NOT More_Escape *);
  1231.  
  1232. END   (* VT100_Process_Escape *);
  1233.  
  1234. (*----------------------------------------------------------------------*)
  1235. (*        Process_Printer_Escapes --- Process printer escape sequence   *)
  1236. (*----------------------------------------------------------------------*)
  1237.  
  1238. PROCEDURE Process_Printer_Escapes( Ch : CHAR );
  1239.  
  1240. (*----------------------------------------------------------------------*)
  1241. (*                                                                      *)
  1242. (*     Procedure: Process_Printer_Escapes                               *)
  1243. (*                                                                      *)
  1244. (*     Purpose:   Processes printer control escape sequences only       *)
  1245. (*                                                                      *)
  1246. (*     Calling Sequence:                                                *)
  1247. (*                                                                      *)
  1248. (*        Process_Printer_Escapes( Ch: CHAR );                          *)
  1249. (*                                                                      *)
  1250. (*           Ch --- Next character in escape sequence                   *)
  1251. (*                                                                      *)
  1252. (*     Called by:  Emulate_Ansi                                         *)
  1253. (*                                                                      *)
  1254. (*----------------------------------------------------------------------*)
  1255.  
  1256. VAR
  1257.    More_Escape : BOOLEAN;
  1258.  
  1259. BEGIN (* Process_Printer_Escapes *)
  1260.  
  1261.    More_Escape := TRUE;
  1262.                                    (* Ignore blanks *)
  1263.    IF ( Ch = ' ' ) THEN
  1264.       BEGIN
  1265.          Escape_Str := Escape_Str + Ch;
  1266.          EXIT;
  1267.       END;
  1268.                                    (* Process char depending upon current *)
  1269.                                    (* escape type mode                    *)
  1270.    CASE Escape_Type OF
  1271.  
  1272.       ' ':  CASE Ch OF
  1273.  
  1274.                '#',
  1275.                '[',
  1276.                'O',
  1277.                '?':   BEGIN
  1278.                          Escape_Str  := Escape_Str + Ch;
  1279.                          Escape_Type := Ch;
  1280.                          EXIT;
  1281.                       END;
  1282.  
  1283.                ELSE;
  1284.  
  1285.             END (* CASE *);
  1286.  
  1287.       '[':  IF ( Ch = 'i' ) THEN
  1288.                BEGIN
  1289.                   Ansi_Printer_Control(' ');
  1290.                   More_Escape := FALSE;
  1291.                END;
  1292.  
  1293.       ELSE;
  1294.  
  1295.    END (* CASE Escape_Type *);
  1296.  
  1297.    IF ( NOT More_Escape ) THEN
  1298.       Escape_Mode := FALSE
  1299.    ELSE
  1300.       BEGIN
  1301.  
  1302.          Escape_Str := Escape_Str + Ch;
  1303.          Ch         := UpCase( Ch );
  1304.  
  1305.          IF Ch IN Lets THEN EXIT;
  1306.  
  1307.          IF Ch IN Digits THEN
  1308.             BEGIN
  1309.                Escape_Register[Escape_Number] :=
  1310.                   ( Escape_Register[Escape_Number] * 10 ) + ORD( Ch ) -
  1311.                                                             ORD( '0' );
  1312.                EXIT;
  1313.             END;
  1314.  
  1315.          CASE Ch OF
  1316.  
  1317.             ';', ',' : BEGIN
  1318.                           Escape_Number                  := Escape_Number + 1;
  1319.                           Escape_Register[Escape_Number] := 0;
  1320.                        END;
  1321.  
  1322.             'T', 'S', '#', '+', '-', '>', '<', '.','?','='
  1323.                         : ;
  1324.             ELSE
  1325.                Escape_Mode := FALSE;
  1326.                WRITE( Lst, Escape_Str );
  1327.  
  1328.          END  (* Case *);
  1329.  
  1330.       END (* NOT More_Escape *);
  1331.  
  1332. END   (* Process_Printer_Escapes *);
  1333.  
  1334. (*----------------------------------------------------------------------*)
  1335.  
  1336. BEGIN (* Emulate_ANSI *)
  1337.                                    (* We don't go through DOS here *)
  1338.  
  1339.    Save_Dos_Con       := Use_Dos_Con_Output;
  1340.    Use_Dos_Con_Output := FALSE;
  1341.  
  1342.                                    (* Initialize text terminal mode *)
  1343.    Init_Text_Terminal;
  1344.                                    (* Background, foreground      *)
  1345.  
  1346.    Save_Global_FG        := Global_ForeGround_Color;
  1347.    Save_Global_BG        := Global_BackGround_Color;
  1348.    Save_FG               := ForeGround_Color;
  1349.    Save_BG               := BackGround_Color;
  1350.    Save_EG               := Border_Color;
  1351.  
  1352.                                    (* Set the terminal           *)
  1353.    Ansi_Reset_Terminal;
  1354.                                    (* Loop over input until done *)
  1355.    WHILE ( NOT Done ) DO
  1356.       BEGIN
  1357.  
  1358.          IF KeyPressed THEN
  1359.             BEGIN (* KeyPressed *)
  1360.  
  1361.                Save_Do_Status := Do_Status_Line;
  1362.                Save_FG1 := FG;
  1363.                Save_BG1 := BG;
  1364.  
  1365.                Set_Global_Colors( Save_Global_FG , Save_Global_BG );
  1366.  
  1367.                Handle_Keyboard_Input( Done , Reset_Requested , ClrScr_Request );
  1368.  
  1369.                Set_Global_Colors( Save_FG1 , Save_BG1 );
  1370.  
  1371.                IF Reset_Requested THEN
  1372.                   BEGIN
  1373.                      Clear_Window;
  1374.                      Ansi_Reset_Terminal;
  1375.                   END
  1376.                ELSE IF ClrScr_Request THEN
  1377.                   Clear_Window
  1378.                ELSE IF ( Save_Do_Status <> Do_Status_Line ) THEN
  1379.                   BEGIN
  1380.  
  1381.                      IF Do_Status_Line THEN
  1382.                         Ansi_Last_Line := Max_Screen_Line - 1
  1383.                      ELSE
  1384.                         Ansi_Last_Line := Max_Screen_Line;
  1385.  
  1386.                      Window( 1, 1, Max_Screen_Col, Ansi_Last_Line );
  1387.  
  1388.                      Set_Screen_Size( Ansi_Last_Line , Max_Screen_Col );
  1389.  
  1390.                   END;
  1391.  
  1392.             END   (* KeyPressed *);
  1393.  
  1394.                                    (* Process a script command if any *)
  1395.  
  1396.          IF ( Script_File_Mode AND ( NOT ( Done OR Really_Wait_String ) ) ) THEN
  1397.             BEGIN
  1398.                Get_Script_Command( PibTerm_Command );
  1399.                Execute_Command   ( PibTerm_Command , Done , TRUE );
  1400.             END;
  1401.                                    (* Hold everything while scroll lock on *)
  1402.  
  1403.          IF Scroll_Lock_On THEN
  1404.             Handle_Scroll_Lock;
  1405.                                    (* Handle carrier drop *)
  1406.          IF Carrier_Dropped THEN
  1407.             Handle_Carrier_Drop;
  1408.  
  1409.                                    (* Process char received from comm port *)
  1410.  
  1411.          IF ( Async_Buffer_Head <> Async_Buffer_Tail ) THEN
  1412.             BEGIN  (* Comm_Ch found *)
  1413.  
  1414.                                    (* Get the character *)
  1415.  
  1416.                B := Async_Receive( Comm_Ch );
  1417.  
  1418.                                    (* Strip high bit if requested *)
  1419.  
  1420.                IF Auto_Strip_High_Bit THEN
  1421.                   Comm_Ch := CHR( ORD( Comm_Ch ) AND $7F );
  1422.  
  1423.                                    (* Perform translation *)
  1424.  
  1425.                Comm_Ch := TrTab[Comm_Ch];
  1426.  
  1427.                                    (* Handle printer control mode *)
  1428.  
  1429.                IF Printer_Ctrl_Mode THEN
  1430.                   BEGIN
  1431.                      IF Escape_Mode THEN
  1432.                         Process_Printer_Escapes( Comm_Ch )
  1433.                      ELSE IF ( Comm_Ch = CHR( ESC ) ) THEN
  1434.                         BEGIN
  1435.                            IF Escape_Mode THEN
  1436.                               WRITE( LST , Escape_Str );
  1437.                            Escape_Str         := Comm_Ch;
  1438.                            Escape_Number      := 1;
  1439.                            Escape_Register[1] := 0;
  1440.                            Escape_Mode        := TRUE;
  1441.                            Escape_Type        := ' ';
  1442.                            Getting_Music      := FALSE;
  1443.                         END
  1444.                      ELSE
  1445.                         WRITE( LST, Comm_Ch );
  1446.                   END
  1447.                                    (* Check for special control character *)
  1448.  
  1449.                ELSE IF Special_Comm[ ORD( Comm_Ch ) ] THEN
  1450.                   Handle_VT100_Special( Comm_Ch )
  1451.  
  1452.                                    (* Check for escape sequence to process *)
  1453.  
  1454.                ELSE IF Escape_Mode THEN
  1455.  
  1456.                   CASE VT100_Allowed OF
  1457.                      TRUE:   VT100_Process_Escape( Comm_Ch , Done );
  1458.                      FALSE:  Ansi_Process_Escape( Comm_Ch );
  1459.                   END (* CASE *)
  1460.  
  1461.                ELSE
  1462.                      BEGIN  (* Ordinary character *)
  1463.  
  1464.                         Double_Ch        := ' ';
  1465.  
  1466.                         IF Graphics_Mode THEN
  1467.                            BEGIN (* Graphics Mode *)
  1468.  
  1469.                               IF ORD( Comm_Ch ) IN [ 95 .. 126 ] THEN
  1470.                                  BEGIN
  1471.                                     Graph_Ch := VT100_Graphics_Chars[ ORD( Comm_Ch ) ];
  1472.                                     Comm_Ch  := CHR( Graph_Ch );
  1473.                                  END;
  1474.  
  1475.                               IF Double_Width_Mode THEN
  1476.                                  IF ( Comm_Ch = CHR(196) ) OR
  1477.                                     ( Comm_Ch = CHR(192) ) OR
  1478.                                     ( Comm_Ch = CHR(218) ) THEN
  1479.                                        Double_Ch := CHR( 196 );
  1480.  
  1481.                            END   (* Graphics Mode *);
  1482.  
  1483.                         Display_Character( Comm_Ch );
  1484.  
  1485.                         IF Double_Width_Mode THEN
  1486.                            Display_Character( Double_Ch );
  1487.  
  1488.                         IF Do_Script_Tests THEN
  1489.                            Do_Script_Checks( Comm_Ch );
  1490.  
  1491.                      END  (* Ordinary character *);
  1492.  
  1493.             END (* Comm_Ch found *)
  1494.                                    (* Check if waitstring time exhausted *)
  1495.          ELSE
  1496.             BEGIN
  1497.                Async_Line_Status := Async_Line_Status AND $FD;
  1498.                IF Really_Wait_String THEN
  1499.                   Check_Wait_String_Time;
  1500.                IF ( ( NOT KeyPressed ) AND ( NOT Script_File_Mode ) ) THEN
  1501.                   IF ( Async_Buffer_Head = Async_Buffer_Tail ) THEN
  1502.                      GiveAwayTime( 1 );
  1503.             END;
  1504.  
  1505.       END  (* NOT Done *);
  1506.                                    (* Reset whole screen as window *)
  1507.  
  1508.    Window( 1, 1, Max_Screen_Col, Max_Screen_Line );
  1509.  
  1510.                                    (* Restore colors *)
  1511.  
  1512.    Reset_Attr              := ( ForeGround_Color <> Save_FG ) OR
  1513.                               ( BackGround_Color <> Save_BG );
  1514.    ForeGround_Color        := Save_FG;
  1515.    BackGround_Color        := Save_BG;
  1516.    Border_Color            := Save_EG;
  1517.  
  1518.    Set_Global_Colors( ForeGround_Color , BackGround_Color );
  1519.    Set_Border_Color ( Border_Color );
  1520.  
  1521.    IF Reset_Attr THEN
  1522.       Set_Text_Attributes( 1, 1, Max_Screen_Col, Max_Screen_Line,
  1523.                            ForeGround_Color, BackGround_Color );
  1524.  
  1525.    Use_Dos_Con_Output := Save_Dos_Con;
  1526.  
  1527. END   (* Emulate_ANSI *);
  1528.  
  1529.